﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace GeCo_MenuPrincipal
{
    class CNoyau
    {
        public List<CCaseCarte> listeCaseCarte;
        public List<CEvenement> listeEvenements;

        //  Instancier par le Conteneur /C.Silvent
        private bool evenementsAleatoires;
        private int vitesseJeu;
        private int tailleCarte;
        private int score = 0;
        public int EventCount = 0;
        public int nbrTour;

        static Random r;

        public static Random R
        {
            get { return CNoyau.r; }
            set { CNoyau.r = value; }
        }



        int countEvents = 0;

        //private List<CRepartitionIndividus> listeRepartitionIndividus;

        public CNoyau()
        {
            r = new Random();
            this.listeCaseCarte = new List<CCaseCarte>();
            this.listeEvenements = new List<CEvenement>();
            nbrTour = 0;
            //this.listeRepartitionIndividus = new List<CRepartitionIndividus>();

            // Le conteneur vient instancier ces variables. 
            evenementsAleatoires = Program.conteneur.EvenementsAleatoires;      // Valeur par defaut 
            vitesseJeu = Program.conteneur.VitesseJeu;                          // Valeur par defaut
            tailleCarte = Program.conteneur.TailleCarte;                        // Valeur par defaut
        }


        public bool ProbaMort(int _probaAge)
        {
            bool retour = false;
            int nombreAleatoire;
            nombreAleatoire = r.Next(1, 101);
            if (nombreAleatoire <= _probaAge)
            {
                retour = true;
            }
            return retour;
        }

        //exécuté à chaque T+1
        public void Tour()
        {
            CEtreVivant cible = null;
            CCaseCarte lieuCible = null;
            CEtreVivant cibleReproduction = null;
            CCaseCarte lieuCibleReproduction = null;
            int generateEvent = 0;

            bool droitManger = true;
            bool droitDeplacementAleatoire = true;

            nbrTour++;
            if (evenementsAleatoires == true)
            {
                // Génération des evenements aleatoires
                generateEvent = r.Next(1, 20);
                if (generateEvent == 5)
                {
                    countEvents++;
                    CreerEvenement();
                }
            }

            //Réinitialisation de l'attribut DejaDeplace d'un EV
            foreach (CCaseCarte uneCase in listeCaseCarte)
            {
                foreach (CEtreVivant unEV in uneCase.ListeEtreVivant)
                {
                    unEV.DejaDeplace = false;
                }
            }

            if (evenementsAleatoires == true)
            {
                // Gestion des evenements aleatoires
                if (listeEvenements != null)
                {
                    foreach (CEvenement myEvent in listeEvenements)
                    {
                        myEvent.dureeCourante++;
                        if (myEvent.dureeCourante == myEvent.dureeMax)
                        {
                            NettoyerEvenement(myEvent.id);
                            score += (myEvent.pointsBonus * nbrTour);
                            listeEvenements.Remove(myEvent);
                            break;
                        }
                    }
                    foreach (CCaseCarte c in listeCaseCarte)
                    {
                        foreach (CEvenement myEvent in listeEvenements)
                        {
                            if ((c.X > myEvent.oriX && c.X < myEvent.oriX + myEvent.portee) && (c.Y > myEvent.oriX && c.Y < myEvent.oriY + myEvent.portee))
                            {
                                c.idEvent = myEvent.id;
                                c.NomEvenement = myEvent.nomEvenement;
                            }
                            if (c.NomEvenement == "Eruption")
                            {
                                c.ListeEtreVivant.Clear();
                            }
                            if (c.NomEvenement == "Pluie De Meteores")
                            {
                                if (r.Next(1, 10) == 5)
                                    c.ListeEtreVivant.Clear();
                            }
                            if (c.NomEvenement == "Secheresse")
                            {
                                c.ListeEtreVivant.RemoveAll(s => s.Espece.Contains("Plante"));
                            }
                        }
                    }
                }
            }
            //foreach (CCaseCarte _uneCase in this.listeCaseCarte)         
            for (int i = this.listeCaseCarte.Count - 1; i >= 0; i--)
            {
                if (this.listeCaseCarte[i].ListeEtreVivant.Count > 0)
                {
                    //foreach (CEtreVivant _unEV in _uneCase.ListeEtreVivant)
                    for (int j = this.listeCaseCarte[i].ListeEtreVivant.Count - 1; j >= 0; j--)
                    {
                        if (this.listeCaseCarte[i].NomEvenement == "Ere Glaciaire")
                            this.listeCaseCarte[i].ListeEtreVivant[j].VitesseDeplacement = 5;
                        //incrémentation de l'age pour chaque individu
                        this.listeCaseCarte[i].ListeEtreVivant[j].Age += 1;

                        //decrementation du niveau de faim
                        if ((this.listeCaseCarte[i].ListeEtreVivant[j].NiveauFaim >= 5) && (this.listeCaseCarte[i].ListeEtreVivant[j].Espece != "Plante"))
                        {
                            this.listeCaseCarte[i].ListeEtreVivant[j].NiveauFaim -= 5;
                        }
                        //decrementation de la libido
                        if (this.listeCaseCarte[i].ListeEtreVivant[j].Libido >= 5)
                        {
                            this.listeCaseCarte[i].ListeEtreVivant[j].Libido -= 5;
                        }

                        //test pour savoir si l'invidivu meurt de veillesse
                        if (this.listeCaseCarte[i].ListeEtreVivant[j].Age > this.listeCaseCarte[i].ListeEtreVivant[j].EsperenceVieMax / 2)
                        {
                            if (this.ProbaMort(this.listeCaseCarte[i].ListeEtreVivant[j].Age / this.listeCaseCarte[i].ListeEtreVivant[j].EsperenceVieMax * 100))
                            {
                                //mort de l'etre vivant
                                this.listeCaseCarte[i].SupprimerEtreVivant(this.listeCaseCarte[i].ListeEtreVivant[j]);
                            }
                        }
                        //test pour savoir si l'invidivu meurt de faim
                        else if ((this.listeCaseCarte[i].ListeEtreVivant[j].NiveauFaim < 5) && (this.listeCaseCarte[i].ListeEtreVivant[j].Espece != "Plante"))
                        {
                            //mort de l'etre vivant
                            this.listeCaseCarte[i].SupprimerEtreVivant(this.listeCaseCarte[i].ListeEtreVivant[j]);
                        }
      
                        else
                        {
                            //Si sa libido est inferieur à 50%, il va vouloir se reproduire & qu'il est dans la tranche d'age pour se reproduire
                            if ((this.listeCaseCarte[i].ListeEtreVivant[j].Libido <= this.listeCaseCarte[i].ListeEtreVivant[j].LibidoMax / 2)
                            && (this.listeCaseCarte[i].ListeEtreVivant[j].Age >= this.listeCaseCarte[i].ListeEtreVivant[j].AgeDebutReprod)
                            && (this.listeCaseCarte[i].ListeEtreVivant[j].Age <= this.listeCaseCarte[i].ListeEtreVivant[j].AgeFinReprod))
                            {
                                if (this.listeCaseCarte[i].ListeEtreVivant[j].Espece == "Plante")
                                {
                                    this.SeReproduirePlante(this.listeCaseCarte[i].ListeEtreVivant[j], this.listeCaseCarte[i]);
                                }
                                else if (this.PresenceCibleReproduction(this.listeCaseCarte[i].ListeEtreVivant[j], this.listeCaseCarte[i]) != null)
                                {
                                    cibleReproduction = this.PresenceCibleReproduction(this.listeCaseCarte[i].ListeEtreVivant[j], this.listeCaseCarte[i]);
                                    this.SeReproduire(this.listeCaseCarte[i].ListeEtreVivant[j], cibleReproduction, this.listeCaseCarte[i]);
                                    droitManger = false;
                                    droitDeplacementAleatoire = false;
                                }
                                else
                                {
                                    if (this.TrouverCibleReproduction(this.listeCaseCarte[i].ListeEtreVivant[j], this.listeCaseCarte[i]) != null)
                                    {
                                        lieuCibleReproduction = this.TrouverCibleReproduction(this.listeCaseCarte[i].ListeEtreVivant[j], this.listeCaseCarte[i]);
                                        if ((this.listeCaseCarte[i].NomEvenement != "Tremblement De Terre")
                                            && (this.listeCaseCarte[i].ListeEtreVivant[j].DejaDeplace == false))
                                        {
                                            this.listeCaseCarte[i].ListeEtreVivant[j].DejaDeplace = true;
                                            this.SeRapprocher(lieuCibleReproduction, this.listeCaseCarte[i].ListeEtreVivant[j]);
                                            droitManger = false;
                                            droitDeplacementAleatoire = false;
                                        }

                                    }
                                }
                            }
                            //Si le niveau de faim est inferieur à 50% il va vouloir chasser
                            if (droitManger == true)
                            {
                                if ((this.listeCaseCarte[i].ListeEtreVivant[j].NiveauFaim <= this.listeCaseCarte[i].ListeEtreVivant[j].NiveauFaimMax / 2)
                                   && (this.listeCaseCarte[i].ListeEtreVivant[j].Espece != "Plante"))
                                {
                                    if (this.PresenceCible(this.listeCaseCarte[i].ListeEtreVivant[j], this.listeCaseCarte[i]))
                                    {
                                        cible = this.RecupererCible(this.listeCaseCarte[i].ListeEtreVivant[j], this.listeCaseCarte[i]);
                                        this.MangerCible(this.listeCaseCarte[i].ListeEtreVivant[j], cible, this.listeCaseCarte[i]);
                                        droitDeplacementAleatoire = false;
                                    }
                                    else
                                    {
                                        if (this.TrouverCible(this.listeCaseCarte[i].ListeEtreVivant[j], this.listeCaseCarte[i].ListeEtreVivant[j].EspecePrefere) != null)
                                        {
                                            lieuCible = this.TrouverCible(this.listeCaseCarte[i].ListeEtreVivant[j], this.listeCaseCarte[i].ListeEtreVivant[j].EspecePrefere);
                                            if ((this.listeCaseCarte[i].NomEvenement != "Tremblement De Terre")
                                                && (this.listeCaseCarte[i].ListeEtreVivant[j].DejaDeplace == false))
                                            {
                                                this.listeCaseCarte[i].ListeEtreVivant[j].DejaDeplace = true;
                                                this.SeRapprocher(lieuCible, this.listeCaseCarte[i].ListeEtreVivant[j]);
                                                droitDeplacementAleatoire = false;
                                            }
                                        }
                                    }
                                }
                            }
                            if (droitDeplacementAleatoire == true)
                            {
                                //si l'individu n'a rien a faire, il se deplace aleatoirement sur une case a proximité
                                if (ProbaDeplacer(this.listeCaseCarte[i].ListeEtreVivant[j].VitesseDeplacement) == true
                                    && (this.listeCaseCarte[i].ListeEtreVivant[j].Espece != "Plante"))
                                {
                                    if ((this.listeCaseCarte[i].NomEvenement != "Tremblement De Terre")
                                        && (this.listeCaseCarte[i].ListeEtreVivant[j].DejaDeplace == false))
                                    {
                                        this.listeCaseCarte[i].ListeEtreVivant[j].DejaDeplace = true;
                                        SeDeplacer(this.listeCaseCarte[i].ListeEtreVivant[j]);
                                    }
                                }
                            }
                        }
                        droitManger = true;
                        droitDeplacementAleatoire = true;
                    }
                }
            }
            score++;
        }

        //renvoie le score en cours de la partie
        public int CalculerScore()
        {
            return this.score;
        }

        //decision de fin de partie
        public bool FinDePartie()
        {
            if (Menu.NbrHerbivores == 0 || Menu.NbrCarnivores == 0 || Menu.NbrPlantes == 0)
                return true;
            else
                return false;
        }

        public void NettoyerEvenement(int id)
        {
            foreach (CCaseCarte c in listeCaseCarte)
            {
                if (c.idEvent == id)
                {
                    c.NomEvenement = "Aucun Evenement";
                    c.idEvent = 0;
                }
            }
            EventCount++;
        }

        public void CreerEvenement()
        {
            CEvenement myEvent = new CEvenement();
            int chooseEvent;
            chooseEvent = r.Next(1, 6);
            if (chooseEvent == 1)
            {
                myEvent.portee = 5;
                myEvent.dureeMax = 20;
                myEvent.nomEvenement = "Eruption";
                myEvent.pointsBonus = 5;
            }
            else if (chooseEvent == 2)
            {
                myEvent.portee = 7;
                myEvent.dureeMax = 20;
                myEvent.nomEvenement = "Tremblement De Terre";
                myEvent.pointsBonus = 2;
            }
            else if (chooseEvent == 3)
            {
                myEvent.portee = 7;
                myEvent.dureeMax = 20;
                myEvent.nomEvenement = "Ere Glaciaire";
                myEvent.pointsBonus = 3;
            }
            else if (chooseEvent == 4)
            {
                myEvent.portee = 5;
                myEvent.dureeMax = 20;
                myEvent.nomEvenement = "Pluie De Meteores";
                myEvent.pointsBonus = 4;
            }
            else if (chooseEvent == 5)
            {
                myEvent.portee = 5;
                myEvent.dureeMax = 20;
                myEvent.nomEvenement = "Secheresse";
                myEvent.pointsBonus = 3;
            }
            myEvent.dureeCourante = 0;
            myEvent.oriX = r.Next(1, Program.conteneur.TailleCarte - myEvent.portee);
            myEvent.oriY = r.Next(1, Program.conteneur.TailleCarte - myEvent.portee);
            myEvent.id = countEvents;
            listeEvenements.Add(myEvent);
        }

        //cette fonction indique si oui ou non un etre vivant possède un autre etre vivant du même libelle pour se reproduire sur sa case
        private CEtreVivant PresenceCibleReproduction(CEtreVivant _predateur, CCaseCarte _lieu)
        {
            CEtreVivant retour = null;
            //parcours de chaque être vivant présents sur la case 
            foreach (CEtreVivant _unEV in _lieu.ListeEtreVivant)
            {
                if ((_predateur.Libelle == _unEV.Libelle) && (_predateur.Sexe != _unEV.Sexe) && (_predateur != _unEV))
                {
                    retour = _unEV;
                }
            }
            return retour;
        }

        //cette fonction indique si oui ou non une espèce préférée est présente ou pas sur la case en cours
        private bool PresenceCible(CEtreVivant _predateur, CCaseCarte _lieu)
        {
            bool retour = false;
            //parcours de chaque être vivant présents sur la case 
            foreach (CEtreVivant _unEV in _lieu.ListeEtreVivant)
            {
                //parcours de chaque etres vivants présents dans la liste des espèces préférées du prédateur
                foreach (string _especePref in _predateur.EspecePrefere)
                {
                    if (_unEV.Libelle == _especePref)
                    {
                        retour = true;
                    }
                }
            }
            return retour;
        }

        //cette fonction retourne l'etre vivant qui va etre mangé par le predateur
        private CEtreVivant RecupererCible(CEtreVivant _predateur, CCaseCarte _lieu)
        {
            CEtreVivant retour = null;
            //parcours de chaque être vivant présents sur la case 
            foreach (CEtreVivant _unEV in _lieu.ListeEtreVivant)
            {
                //parcours de chaque etres vivants présents dans la liste des espèces préférées du prédateur
                foreach (string _especePref in _predateur.EspecePrefere)
                {
                    if (_unEV.Libelle == _especePref)
                    {
                        retour = _unEV;
                    }
                }
            }
            return retour;
        }

        private void MangerCible(CEtreVivant _predateur, CEtreVivant _proie, CCaseCarte _lieu)
        {
            this.SupprimerEtreVivantSurCase(_proie, _lieu.X, _lieu.Y);
            // _predateur.NiveauFaim += _predateur.NiveauFaimMax / 2;
        }

        //on retourne la case où se trouve la cible cherchée la plus proche ou null si rien trouvé
        private CCaseCarte TrouverCibleReproduction(CEtreVivant _predateur, CCaseCarte _lieu)
        {
            double distance = tailleCarte;
            CCaseCarte retour = null;

            //parcours du plateau pour trouver une espèce préférée du prédateur en cours
            foreach (CCaseCarte _uneCase in listeCaseCarte)
            {
                for (int i = 0; i < _uneCase.ListeEtreVivant.Count; i++)
                {
                    //est-ce que le libelle de l'etre vivant sur la case correspond à une des espèces préférés du prédateur en cours 
                    //et est-elle plus proches que la dernière cible enregistrée
                    if ((_predateur.Libelle == _uneCase.ListeEtreVivant[i].Libelle)
                        && (_predateur.Sexe != _uneCase.ListeEtreVivant[i].Sexe)
                        && (CalculerDistance(_uneCase.ListeEtreVivant[i], _predateur) < distance) && (_lieu != _uneCase))
                    {
                        distance = CalculerDistance(_uneCase.ListeEtreVivant[i], _predateur); //on enregistre la distance de la cible la plus proche
                        retour = _uneCase; //on enregistre la case dont on va se rapprocher
                    }
                }
            }

            return retour;
        }

        //on retourne la case où se trouve la cible cherchée la plus proche ou null si rien trouvé
        private CCaseCarte TrouverCible(CEtreVivant _predateur, List<String> _lesEspecesPreferees)
        {
            double distance = tailleCarte;
            CCaseCarte retour = null;

            //parcours des espèces préférées du prédateur en cours
            foreach (String _proie in _lesEspecesPreferees)
            {
                //parcours du plateau pour trouver une espèce préférée du prédateur en cours
                foreach (CCaseCarte _uneCase in listeCaseCarte)
                {
                    for (int i = 0; i < _uneCase.ListeEtreVivant.Count; i++)
                    {
                        //est-ce que le libelle de l'etre vivant sur la case correspond à une des espèces préférés du prédateur en cours 
                        //et est-elle plus proches que la dernière cible enregistrée
                        if (_proie == _uneCase.ListeEtreVivant[i].Libelle && CalculerDistance(_uneCase.ListeEtreVivant[i], _predateur) < distance)
                        {
                            distance = CalculerDistance(_uneCase.ListeEtreVivant[i], _predateur); //on enregistre la distance de la cible la plus proche
                            retour = _uneCase; //on enregistre la case dont on va se rapprocher
                        }
                    }
                }
            }
            return retour;
        }

        //Calcul la distance entre deux etres vivants
        private double CalculerDistance(CEtreVivant _cible, CEtreVivant _predateur)
        {
            double resultat = System.Math.Sqrt(Math.Pow(_cible.X - _predateur.X, 2) + Math.Pow(_cible.Y - _predateur.Y, 2));
            return resultat;
        }

        //se rapprocher d'une case où se trouve la proie à partir de l'etre vivant en cours
        private void SeRapprocher(CCaseCarte _lieu, CEtreVivant _predateur)
        {
            if (_lieu.X != _predateur.X || _lieu.Y != _predateur.Y)
            {

                if (_lieu.X > _predateur.X)
                {
                    this.DeplacerEtreVivant(_predateur, _predateur.X + 1, _predateur.Y);
                }
                else if (_lieu.X < _predateur.X)
                {
                    this.DeplacerEtreVivant(_predateur, _predateur.X - 1, _predateur.Y);
                }

                if (_lieu.Y > _predateur.Y)
                {
                    this.DeplacerEtreVivant(_predateur, _predateur.X, _predateur.Y + 1);
                }
                else if (_lieu.Y < _predateur.Y)
                {
                    this.DeplacerEtreVivant(_predateur, _predateur.X, _predateur.Y - 1);
                }
            }
        }

        //déplacement aléatoire quand y a rien d'autre à faire
        public void SeDeplacer(CEtreVivant _etreVivant)
        {
            int nombreAleatoire = r.Next(1, 4);
            if (_etreVivant.X == 0 || _etreVivant.X == tailleCarte - 1 || _etreVivant.Y == 0 || _etreVivant.Y == tailleCarte - 1)
            {
                //ne pas sortir de la carte au coordonné X=0
                if (_etreVivant.X == 0)
                {
                    if (_etreVivant.Y == 0)
                    {
                        if (nombreAleatoire == 1)
                        {
                            DeplacerEtreVivant(_etreVivant, _etreVivant.X + 1, _etreVivant.Y);
                        }
                        else if (nombreAleatoire == 2)
                        {
                            DeplacerEtreVivant(_etreVivant, _etreVivant.X, _etreVivant.Y + 1);
                        }
                        else if (nombreAleatoire == 3)
                        {
                            DeplacerEtreVivant(_etreVivant, _etreVivant.X + 1, _etreVivant.Y + 1);
                        }
                    }
                    else if (_etreVivant.Y == tailleCarte - 1)
                    {
                        if (nombreAleatoire == 1)
                        {
                            DeplacerEtreVivant(_etreVivant, _etreVivant.X + 1, _etreVivant.Y);
                        }
                        else if (nombreAleatoire == 2)
                        {
                            DeplacerEtreVivant(_etreVivant, _etreVivant.X, _etreVivant.Y - 1);
                        }
                        else if (nombreAleatoire == 3)
                        {
                            DeplacerEtreVivant(_etreVivant, _etreVivant.X + 1, _etreVivant.Y - 1);
                        }
                    }
                    else
                    {
                        if (nombreAleatoire == 1)
                        {
                            DeplacerEtreVivant(_etreVivant, _etreVivant.X + 1, _etreVivant.Y);
                        }
                        else if (nombreAleatoire == 2)
                        {
                            DeplacerEtreVivant(_etreVivant, _etreVivant.X, _etreVivant.Y - 1);
                        }
                        else if (nombreAleatoire == 3)
                        {
                            DeplacerEtreVivant(_etreVivant, _etreVivant.X + 1, _etreVivant.Y + 1);
                        }
                    }
                }
                //ne pas sortir de la carte au coordonné Y=0
                else if (_etreVivant.Y == 0)
                {
                    if (_etreVivant.X == tailleCarte - 1)
                    {
                        if (nombreAleatoire == 1)
                        {
                            DeplacerEtreVivant(_etreVivant, _etreVivant.X, _etreVivant.Y + 1);
                        }
                        else if (nombreAleatoire == 2)
                        {
                            DeplacerEtreVivant(_etreVivant, _etreVivant.X - 1, _etreVivant.Y);
                        }
                        else if (nombreAleatoire == 3)
                        {
                            DeplacerEtreVivant(_etreVivant, _etreVivant.X - 1, _etreVivant.Y + 1);
                        }
                    }
                    else
                    {
                        if (nombreAleatoire == 1)
                        {
                            DeplacerEtreVivant(_etreVivant, _etreVivant.X, _etreVivant.Y + 1);
                        }
                        else if (nombreAleatoire == 2)
                        {
                            DeplacerEtreVivant(_etreVivant, _etreVivant.X - 1, _etreVivant.Y);
                        }
                        else if (nombreAleatoire == 3)
                        {
                            DeplacerEtreVivant(_etreVivant, _etreVivant.X + 1, _etreVivant.Y + 1);
                        }
                    }
                }
                else if (_etreVivant.X == tailleCarte - 1)
                {
                    if (_etreVivant.Y == tailleCarte - 1)
                    {
                        if (nombreAleatoire == 1)
                        {
                            DeplacerEtreVivant(_etreVivant, _etreVivant.X - 1, _etreVivant.Y);
                        }
                        else if (nombreAleatoire == 2)
                        {
                            DeplacerEtreVivant(_etreVivant, _etreVivant.X, _etreVivant.Y - 1);
                        }
                        else if (nombreAleatoire == 3)
                        {
                            DeplacerEtreVivant(_etreVivant, _etreVivant.X - 1, _etreVivant.Y - 1);
                        }
                    }
                    else
                    {
                        if (nombreAleatoire == 1)
                        {
                            DeplacerEtreVivant(_etreVivant, _etreVivant.X - 1, _etreVivant.Y);
                        }
                        else if (nombreAleatoire == 2)
                        {
                            DeplacerEtreVivant(_etreVivant, _etreVivant.X, _etreVivant.Y + 1);
                        }
                        else if (nombreAleatoire == 3)
                        {
                            //ne correspond pas a ce que tu fais au dessus, normal?
                            DeplacerEtreVivant(_etreVivant, _etreVivant.X, _etreVivant.Y - 1);
                            DeplacerEtreVivant(_etreVivant, _etreVivant.X - 1, _etreVivant.Y);
                        }
                    }
                }
                else if (_etreVivant.Y == tailleCarte - 1)
                {
                    if (nombreAleatoire == 1)
                    {
                        DeplacerEtreVivant(_etreVivant, _etreVivant.X, _etreVivant.Y - 1);
                    }
                    else if (nombreAleatoire == 2)
                    {
                        DeplacerEtreVivant(_etreVivant, _etreVivant.X + 1, _etreVivant.Y);
                    }
                    else if (nombreAleatoire == 3)
                    {
                        DeplacerEtreVivant(_etreVivant, _etreVivant.X + 1, _etreVivant.Y - 1);
                    }
                }

            }
            else
            {
                Random r2;
                r2 = new Random();
                int aleatoire = r2.Next(1, 5);
                switch (aleatoire)
                {
                    case 1:
                        DeplacerEtreVivant(_etreVivant, _etreVivant.X + 1, _etreVivant.Y);
                        break;
                    case 2:
                        DeplacerEtreVivant(_etreVivant, _etreVivant.X - 1, _etreVivant.Y);
                        break;
                    case 3:
                        DeplacerEtreVivant(_etreVivant, _etreVivant.X, _etreVivant.Y + 1);
                        break;
                    case 4:
                        DeplacerEtreVivant(_etreVivant, _etreVivant.X, _etreVivant.Y - 1);
                        break;
                }
            }
        }



        public bool ProbaDeplacer(int _vitesseDeplacement)
        {
            bool retour = false;
            int nombreAleatoire;
            nombreAleatoire = r.Next(0, 9);
            if (nombreAleatoire > _vitesseDeplacement)
            {
                retour = true;
            }
            return retour;
        }


        //méthode qui ajoute un être vivant passé en paramètre aléatoirement sur une case 
        public void AjouterEtreVivantSurCaseAleatoire(CEtreVivant _etreVivant)
        {
            int nbrAleatoire = r.Next(0, Program.conteneur.TailleCarte * Program.conteneur.TailleCarte);
            //on va assigner a une case aléatoire l'etre vivant (nombre aléatoire allant de 0 à 49 car le 50 n'est pas inclut
            listeCaseCarte[nbrAleatoire].AjouterEtreVivant(_etreVivant);
            _etreVivant.X = listeCaseCarte[nbrAleatoire].X;
            _etreVivant.Y = listeCaseCarte[nbrAleatoire].Y;
        }

        //méthode qui crée une instance d'être vivant en fonction du type et du libelle de l'espece
        public CEtreVivant CreerEtreVivant(string _typeEspece, string _libelleEspece)
        {
            CEtreVivant unEtreVivant = null;
            switch (_typeEspece)
            {
                case "Carnivore":
                    CCarnivore unCarnivore = new CCarnivore(TrouverIndex(_libelleEspece));
                    unEtreVivant = unCarnivore;
                    break;
                case "Herbivore":
                    CHerbivore unHerbivore = new CHerbivore(TrouverIndex(_libelleEspece));
                    unEtreVivant = unHerbivore;
                    break;
                case "Plante":
                    CPlante unePlante = new CPlante(TrouverIndex(_libelleEspece));
                    unEtreVivant = unePlante;
                    break;
            }
            return unEtreVivant;
        }



        //On deplace un EV sur une case avec un x et un y donné
        public void DeplacerEtreVivant(CEtreVivant _etreVivant, int _xDest, int _yDest)
        {
            int xOrig = _etreVivant.X;
            int yOrig = _etreVivant.Y;
            this.AjouterEtreVivantSurCase(_etreVivant, _xDest, _yDest);
            this.SupprimerEtreVivantSurCase(_etreVivant, xOrig, yOrig);
        }

        //Méthode appellé par DeplacerEtreVivant()
        public void AjouterEtreVivantSurCase(CEtreVivant _etreVivant, int _x, int _y)
        {
            int foo = 0;
            // On cherche l'occurence de C pour trouver une correspondance entre _x et _y 
            // Une fois réalisé on ajoute l'etre vivant à la case
            //foreach (CCaseCarte c in listeCaseCarte)
            while (listeCaseCarte[foo].X != _x || listeCaseCarte[foo].Y != _y)
            {
                foo++;
            }
            _etreVivant.X = _x;
            _etreVivant.Y = _y;
            listeCaseCarte[foo].AjouterEtreVivant(_etreVivant);
        }
        //Méthode appellé par DeplacerEtreVivant()
        public void SupprimerEtreVivantSurCase(CEtreVivant _etreVivant, int _x, int _y)
        {
            int foo = 0;
            // On cherche l'occurence de C pour trouver une correspondance entre _x et _y 
            // Une fois réalisé on supprime l'etre vivant à la case
            //foreach (CCaseCarte c in listeCaseCarte)
            while (listeCaseCarte[foo].X != _x || listeCaseCarte[foo].Y != _y)
            {
                foo++;
            }
            listeCaseCarte[foo].SupprimerEtreVivant(_etreVivant);


        }

        public void LancerPartie()
        {
            CEtreVivant unEtreVivant = null;
            EventCount = 0;

            //creation des cases
            for (int i = 0; i < Program.conteneur.TailleCarte; i++)
            {
                for (int j = 0; j < Program.conteneur.TailleCarte; j++)
                {
                    CCaseCarte uneCase = new CCaseCarte(i, j);
                    uneCase.NomEvenement = "Aucun Evenement";
                    this.listeCaseCarte.Add(uneCase);
                }
            }

            //creation des etres vivants qui se trouvent dans la liste
            for (int i = 0; i < Program.conteneur.ListeIndividus.Count; i++)
            {
                for (int j = 0; j < Convert.ToInt32(Program.conteneur.ListeIndividus[i].Nombre); j++)
                {
                    unEtreVivant = this.CreerEtreVivant(Program.conteneur.ListeIndividus[i].TypeEspece, Program.conteneur.ListeIndividus[i].NomEspece);
                    this.AjouterEtreVivantSurCaseAleatoire(unEtreVivant);
                }
            }
        }

        public void SeReproduirePlante(CEtreVivant _etreVivant, CCaseCarte _lieu)
        {
            CEtreVivant unEtreVivant = null;

            unEtreVivant = this.CreerEtreVivant(_etreVivant.Espece, _etreVivant.Libelle);
            _lieu.AjouterEtreVivant(unEtreVivant);
            this.SeDeplacer(unEtreVivant);
            _etreVivant.Libido += _etreVivant.LibidoMax / 2;

        }

        public void SeReproduire(CEtreVivant _etreVivant1, CEtreVivant _etreVivant2, CCaseCarte _lieu)
        {
            CEtreVivant unEtreVivant = null;

            unEtreVivant = this.CreerEtreVivant(_etreVivant1.Espece, _etreVivant1.Libelle);
            _lieu.AjouterEtreVivant(unEtreVivant);
            _etreVivant1.Libido += _etreVivant1.LibidoMax / 2;
            _etreVivant2.Libido += _etreVivant2.LibidoMax / 2;
            if (_etreVivant2.Libido > _etreVivant2.LibidoMax)
            {
                _etreVivant2.LibidoMax = _etreVivant2.LibidoMax;
            }
        }

        public int TrouverIndex(string _libelle)
        {
            int i = 0;
            foreach (CIndividus item in Program.conteneur.ListeIndividus)
            {
                if (item.NomEspece == _libelle)
                    return i;
                i++;
            }
            return 0;

        }

        public int VitesseJeu
        {
            get { return vitesseJeu; }
            set { vitesseJeu = value; }
        }

        public int TailleCarte
        {
            get { return tailleCarte; }
            set { tailleCarte = value; }
        }



    }
}
